Pix2Pixアルゴリズムを利用して、欠損のある画像を補正する機械学習モデルを作成する

import random
from PIL import Image, ImageDraw, ImageFilter
import math
import os

random.seed(42)

def create_sun_stamp(width=500, height=500, color='black', variation=0.03):
    image = Image.new('RGB', (width, height), color='white')
    draw = ImageDraw.Draw(image)

    center_x = width // 2 + random.randint(-int(width*variation), int(width*variation))
    center_y = height // 2 + random.randint(-int(height*variation), int(height*variation))

    # 太陽の本体（円）を描画
    sun_radius = min(width, height) // 5 * (1 + random.uniform(-variation, variation))
    draw.ellipse([center_x - sun_radius, center_y - sun_radius,
                  center_x + sun_radius, center_y + sun_radius],
                 fill=color)

    # 光線を描画
    num_rays = random.randint(8, 8)  # ランダムな数の光線
    for i in range(num_rays):
        angle = 2 * math.pi * i / num_rays + random.uniform(-0.1, 0.1)
        ray_length = sun_radius * (1.5 + random.uniform(-variation, variation))

        start_x = center_x + int((sun_radius*0.95) * math.cos(angle))
        start_y = center_y + int((sun_radius*0.95) * math.sin(angle))

        end_x = center_x + int(ray_length * math.cos(angle))
        end_y = center_y + int(ray_length * math.sin(angle))

        # 線の太さを調整（handprintと同様の計算方法）
        ray_width = int(sun_radius / 1.4 * (1 + random.uniform(-variation/2, variation/2)))

        # 光線を描画
        draw.line([start_x, start_y, end_x, end_y], fill=color, width=ray_width)

        # 光線の先端を丸く
        draw.ellipse([end_x - ray_width//2, end_y - ray_width//2,
                      end_x + ray_width//2, end_y + ray_width//2],
                     fill=color)

    # インクの染み出し効果
    for _ in range(2000):
        x = random.randint(0, width-1)
        y = random.randint(0, height-1)
        if image.getpixel((x, y)) == (0, 0, 0):  # 黒色の場合
            for dx in range(-2, 3):
                for dy in range(-2, 3):
                    if 0 <= x+dx < width and 0 <= y+dy < height:
                        if random.random() < 0.3:
                            image.putpixel((x+dx, y+dy), color)

    image = image.filter(ImageFilter.GaussianBlur(radius=1))

    return image

def generate_multiple_sun_stamps(count, width=500, height=500, color='black', output_dir='sun_stamps'):
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    for i in range(count):
        sun_stamp = create_sun_stamp(width, height, color)
        filename = f'sun_stamp_{i+1:04d}.png'
        sun_stamp.save(os.path.join(output_dir, filename))
        print(f"Generated {filename}")

def main():
    generate_multiple_sun_stamps(100, color=(0, 0, 0), output_dir='random_sun_stamps')

if __name__ == "__main__":
    main()

import os
from PIL import Image, ImageDraw
import random

random.seed(42)

def create_partially_masked_image(image_path, output_path, mask_size_range=(50, 150), num_masks=1):
    # 画像を開く
    with Image.open(image_path) as img:
        # 画像のコピーを作成
        masked_img = img.copy()
        draw = ImageDraw.Draw(masked_img)

        for _ in range(num_masks):
            # ランダムなマスクサイズを選択
            mask_width = random.randint(*mask_size_range)
            mask_height = random.randint(*mask_size_range)

            # ランダムな位置を選択
            x = random.randint(0, img.width - mask_width)
            y = random.randint(0, img.height - mask_height)

            # 白い長方形を描画
            draw.rectangle([x, y, x + mask_width, y + mask_height], fill="white")

        # 処理後の画像を保存
        masked_img.save(output_path)

def process_image_directory(input_dir, output_dir, mask_size_range=(50, 150), num_masks=1):

    # 出力ディレクトリが存在しない場合は作成
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    # 入力ディレクトリ内の全画像を処理
    for filename in os.listdir(input_dir):
        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
            input_path = os.path.join(input_dir, filename)
            output_path = os.path.join(output_dir, f"masked_{filename}")
            create_partially_masked_image(input_path, output_path, mask_size_range, num_masks)
            print(f"Processed: {filename}")

def main():

    # 使用例
    input_directory = "./random_sun_stamps"
    output_directory = "./random_sun_stamps_masked"
    process_image_directory(input_directory, output_directory, mask_size_range=(50, 150), num_masks=2)

if __name__ == "__main__":

    main()

import os
from PIL import Image

def resize_image(input_path, output_path, size=(256, 256)):
    with Image.open(input_path) as img:
        # オリジナルの画像のアスペクト比を計算
        aspect_ratio = img.width / img.height

        if aspect_ratio > 1:
            # 横長の画像
            new_width = size[0]
            new_height = int(new_width / aspect_ratio)
        else:
            # 縦長または正方形の画像
            new_height = size[1]
            new_width = int(new_height * aspect_ratio)

        # アスペクト比を保持してリサイズ
        img_resized = img.resize((new_width, new_height), Image.LANCZOS)

        # 新しい画像を作成（背景は白）
        new_img = Image.new("RGB", size, (255, 255, 255))

        # リサイズした画像を中央に配置
        paste_x = (size[0] - new_width) // 2
        paste_y = (size[1] - new_height) // 2
        new_img.paste(img_resized, (paste_x, paste_y))

        # 保存
        new_img.save(output_path)

def process_directory(input_dir, output_dir):
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)

    for filename in os.listdir(input_dir):
        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
            input_path = os.path.join(input_dir, filename)
            output_path = os.path.join(output_dir, filename)
            resize_image(input_path, output_path)
            print(f"Processed: {filename}")

input_directory = "images/resize/inputs"
output_directory = "images/resize/outputs"
process_directory(input_directory, output_directory)

import os
from PIL import Image

def concat_images(folder1, folder2, output_folder):
    # フォルダー内のJPEGファイルをリストアップ
    files1 = sorted([f for f in os.listdir(folder1) if f.lower().endswith('.jpg') or f.lower().endswith('.png', '.jpg', '.jpeg', '.bmp', '.gif')])
    files2 = sorted([f for f in os.listdir(folder2) if f.lower().endswith('.jpg') or f.lower().endswith('.png', '.jpg', '.jpeg', '.bmp', '.gif')])

    # 出力フォルダーが存在しない場合は作成
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)

    # 各ペアの画像を連結
    for i, (file1, file2) in enumerate(zip(files1, files2)):
        # 画像を開く
        img1 = Image.open(os.path.join(folder1, file1))
        img2 = Image.open(os.path.join(folder2, file2))

        # 画像のサイズを確認
        if img1.size != (256, 256) or img2.size != (256, 256):
            print(f"警告: {file1}または{file2}のサイズが256x256ではありません。スキップします。")
            continue

        # 新しい画像を作成
        new_img = Image.new('RGB', (512, 256))

        # 画像を配置
        new_img.paste(img1, (0, 0))
        new_img.paste(img2, (256, 0))

        # 新しい画像を保存(JPEG形式)
        file_name_core = file1[:3]
        output_filename = f"{file_name_core}.jpg"
        new_img.save(os.path.join(output_folder, output_filename))

folder1 = "images/concat/input_a"
folder2 = "images/concat/input_b"
output_folder = "images/concat/output"

concat_images(folder1, folder2, output_folder)

train_dataset = tf.data.Dataset.list_files('ここを学習用画像データのPATHに書き換える 例:　/content/dataset/train/*.jpg')
train_dataset = train_dataset.map(load_image_train,
                                  num_parallel_calls=tf.data.AUTOTUNE)
train_dataset = train_dataset.shuffle(BUFFER_SIZE)
train_dataset = train_dataset.batch(BATCH_SIZE)

try:
  test_dataset = tf.data.Dataset.list_files('ここをテスト用画像データの配置PATHに書き換える 例:　/content/dataset/test/*.jpg')
except tf.errors.InvalidArgumentError:
  test_dataset = tf.data.Dataset.list_files('ここを評価用画像データの配置PATHに書き換える(任意) 例:　/content/dataset/val/*.jpg')
test_dataset = test_dataset.map(load_image_test)
test_dataset = test_dataset.batch(BATCH_SIZE)